package com.gxg.newdemo1.mynewdamo1.signature;

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;


import android.app.Activity;
import android.app.AlertDialog;
import android.content.Context;
import android.content.DialogInterface;
import android.content.res.Configuration;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Color;
import android.os.Bundle;
import android.os.Environment;
import android.util.Log;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.EditText;
import android.widget.ImageView;
import android.widget.Toast;

import com.gxg.newdemo1.mynewdamo1.R;

import cn.org.bjca.anysign.android.api.Interface.OnSignatureResultListener;
import cn.org.bjca.anysign.android.api.core.CachetObj;
import cn.org.bjca.anysign.android.api.core.CommentObj;
import cn.org.bjca.anysign.android.api.core.OCRCapture;
import cn.org.bjca.anysign.android.api.core.OriginalContent;
import cn.org.bjca.anysign.android.api.core.SignRule;
import cn.org.bjca.anysign.android.api.core.SignRule.KWRule;
import cn.org.bjca.anysign.android.api.core.SignRule.SignRuleType;
import cn.org.bjca.anysign.android.api.core.SignRule.XYZRule;
import cn.org.bjca.anysign.android.api.core.SignatureAPI;
import cn.org.bjca.anysign.android.api.core.SignatureObj;
import cn.org.bjca.anysign.android.api.core.Signer;
import cn.org.bjca.anysign.android.api.core.Signer.SignerCardType;
import cn.org.bjca.anysign.android.api.core.domain.AnySignBuild;
import cn.org.bjca.anysign.android.api.core.domain.CommentInputType;
import cn.org.bjca.anysign.android.api.core.domain.DataType;
import cn.org.bjca.anysign.android.api.core.domain.SignResult;
import cn.org.bjca.anysign.android.api.core.domain.SignatureType;

public class TestSPSAPIActivity extends Activity implements OnClickListener {

	private Button initApi, sign, sign1, Masssign, photo_evidence, sound_evidence, evidence_Hash, addPic,
			isReadyToUpload, genData, resetAPI, upload, saveCacheWithSession, readCacheWithSessionId,
			deleteCacheWithSessionId,hasCacheWithSessionId;

	private SignatureAPI api;
	private Activity app = this;
	private byte[] bTemplate = null;
	
	private int apiResult;
	
	private String root_path = Environment.getExternalStorageDirectory() + "/anysign/";//保存数据文件路径
	private String path_anySign = root_path +"anysign_minicore.txt";//加密包路径
	
	private String mSession = "";
	
	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main_qianming);
		
		
		initApi = (Button) findViewById(R.id.init_api);// 初始化API
		sign = (Button) findViewById(R.id.singlesign);// 单签
		sign1 = (Button) findViewById(R.id.singlesign1);// 单签
		Masssign = (Button) findViewById(R.id.masssign);// 批注
		addPic = (Button) findViewById(R.id.addPic);
		photo_evidence = (Button) findViewById(R.id.photo_evidence);// 图片证据
		sound_evidence = (Button) findViewById(R.id.sound_evidence);// 音频证据
		evidence_Hash = (Button) findViewById(R.id.evidenceHash);
		isReadyToUpload = (Button) findViewById(R.id.isReadyToUpload);// 数据是否准备就绪
		genData = (Button) findViewById(R.id.gen_data);// 生成数据加密包
		upload = (Button) findViewById(R.id.gen_upload);// 上传加密数据包
		resetAPI = (Button) findViewById(R.id.reset_api);// 重新初始化API
		
		saveCacheWithSession = (Button) findViewById(R.id.setSessionID);
		readCacheWithSessionId = (Button) findViewById(R.id.restoreSession);
		deleteCacheWithSessionId = (Button) findViewById(R.id.deleteSession);
		hasCacheWithSessionId = (Button) findViewById(R.id.hasSession);

		initApi.setOnClickListener(this);
		sign.setOnClickListener(this);
		sign1.setOnClickListener(this);
		Masssign.setOnClickListener(this);
		addPic.setOnClickListener(this);
		photo_evidence.setOnClickListener(this);
		sound_evidence.setOnClickListener(this);
		evidence_Hash.setOnClickListener(this);
		isReadyToUpload.setOnClickListener(this);
		genData.setOnClickListener(this);
		upload.setOnClickListener(this);
		resetAPI.setOnClickListener(this);
		saveCacheWithSession.setOnClickListener(this);
		readCacheWithSessionId.setOnClickListener(this);
		deleteCacheWithSessionId.setOnClickListener(this);
		hasCacheWithSessionId.setOnClickListener(this);
	}

	
	

	@Override
	public void onClick(View v) {
		if (v.equals(initApi)) {
				initApi();
				Toast.makeText(app, "初始化API成功", Toast.LENGTH_LONG).show();
		} 
		else if (v.equals(sign)) {
			
				if (api !=null) {
					apiResult = api.showSignatureDialog(0);// 弹出单签签名框签名		
					if(apiResult == SignatureAPI.SUCCESS){
						Log.e("tagtag", "成功");
					}else{
						Toast.makeText(TestSPSAPIActivity.this, "错误码："+apiResult , Toast.LENGTH_SHORT).show();
					}
				}else {
					Toast.makeText(app, "请先初始化API", Toast.LENGTH_SHORT).show();
				}

		} 
		else if (v.equals(sign1)) {
			if (api !=null) {
				apiResult = api.showSignatureDialog(1);// 弹出单签签名框签名		
				if(apiResult == SignatureAPI.SUCCESS){
					Log.e("tagtag", "成功");
				}else{
					Toast.makeText(TestSPSAPIActivity.this, "错误码："+apiResult , Toast.LENGTH_SHORT).show();
				}
			}else {
				Toast.makeText(app, "请先初始化API", Toast.LENGTH_SHORT).show();
			}
		}
		else if (v.equals(Masssign)) {

			if (api != null) {
					apiResult = api.showCommentDialog(0);// 弹出批注签名框签名
					if(apiResult == SignatureAPI.SUCCESS){
						
					}else{
						Toast.makeText(TestSPSAPIActivity.this, "错误码："+apiResult , Toast.LENGTH_SHORT).show();
					}
					
				}else {
					Toast.makeText(app, "请先初始化API", Toast.LENGTH_SHORT).show();
				}
		}
		
		else if (v.equals(addPic)) {
			
			if (api != null) {
				
				Bitmap bmp = BitmapFactory.decodeResource(getResources(), R.drawable.ic_launcher);
				ByteArrayOutputStream baos = new ByteArrayOutputStream();
				bmp.compress(Bitmap.CompressFormat.PNG, 100, baos);
				byte[] content = baos.toByteArray();
				
				apiResult = api.addPicAttach(0, content, DataType.IMAGE_PNG);// 弹出批注签名框签名
				if(apiResult == SignatureAPI.SUCCESS){
					
				}else{
					Toast.makeText(TestSPSAPIActivity.this, "错误码："+apiResult , Toast.LENGTH_SHORT).show();
				}
				
			}else {
				Toast.makeText(app, "请先初始化API", Toast.LENGTH_SHORT).show();
			}
		}

		else if (v.equals(photo_evidence)) {

			if (api != null) {
					/*
					 * addEvidence(int signIndex, byte[] content, BioType evidenceType)
					 * 
					 * 添加证据一定要在签名之前
					 * 
					 * 设置第三方自采证据，此数据项的哈希值会保存到证书中
					 * 参数1：signIndex 此证据所有者的index值，如1签名人，则此证书同此签名人绑定
					 * 参数2：content 此证据数据原文二进制数据
					 * 参数3：evidenceType 此证据类型，如枚举中无需要使用的具体值，设置正确evidence类型即可，如PHOTO、AUDIO。
					 */
				
				apiResult = api.addEvidence(0, 0,readFile2BytesByStream(new File(Environment.getExternalStorageDirectory()+"/anysign/evidence.jpg")),	
						DataType.IMAGE_JPEG);
				
				if (apiResult == SignatureAPI.SUCCESS) {
					Toast.makeText(TestSPSAPIActivity.this, "添加图片证据成功",
							Toast.LENGTH_SHORT).show();
				} else {
					Toast.makeText(TestSPSAPIActivity.this, "错误码：" + apiResult,
							Toast.LENGTH_SHORT).show();
				}
			}
			
		} 
		else if (v.equals(sound_evidence)) {
			
				if (api != null) {
					/*
					 * addEvidence(int signIndex, byte[] content, BioType evidenceType)
					 * 
					 * 添加证据一定要在签名之前
					 * 
					 * 设置第三方自采证据，此数据项的哈希值会保存到证书中
					 * 参数1：signIndex 此证据所有者的index值，如1签名人，则此证书同此签名人绑定
					 * 参数2：content 此证据数据原文二进制数据
					 * 参数3：evidenceType 此证据类型，如枚举中无需要使用的具体值，设置正确evidence类型即可，如PHOTO、AUDIO。
					 */
					apiResult = api.addEvidence(0, 1, "123".getBytes(), DataType.MEDIA_WAVE);
					if(apiResult == SignatureAPI.SUCCESS){
						Toast.makeText(TestSPSAPIActivity.this, "添加成功", Toast.LENGTH_SHORT).show();
					}else{
						Toast.makeText(TestSPSAPIActivity.this, "错误码："+apiResult , Toast.LENGTH_SHORT).show();
					}
				}else {
					Toast.makeText(app, "请先初始化API", Toast.LENGTH_SHORT).show();
				}
		} 
		else if (v.equals(evidence_Hash)) {
			if (api != null) {
				if(apiResult == SignatureAPI.SUCCESS){
					Toast.makeText(TestSPSAPIActivity.this, "添加成功", Toast.LENGTH_SHORT).show();
				}else{
					Toast.makeText(TestSPSAPIActivity.this, "错误码："+apiResult , Toast.LENGTH_SHORT).show();
				}
			}else {
				Toast.makeText(app, "请先初始化API", Toast.LENGTH_SHORT).show();
			}
		}
		else if (v.equals(isReadyToUpload)) {
			
			if (api != null) {
				/*
				 * isReadyToGen() 判断数据是否准备就绪
				 */
				if (api.isReadyToGen() == 0) {
					Toast.makeText(app, "数据准备就绪", Toast.LENGTH_SHORT).show();
				}else {
					Toast.makeText(TestSPSAPIActivity.this, "错误码：" + api.isReadyToGen()+"", Toast.LENGTH_SHORT).show();
				}
				
			} else {
				Toast.makeText(app, "请先初始化API", Toast.LENGTH_SHORT).show();
			}
		}
		else if (v.equals(genData)) {
			if (api != null) {
				
				/*
				 * genSignRequest() 获取加密数据包
				 */
				String str = (String) api.genSignRequest();// 生成上传信手书服务端报文
//				
//				FileUtils.writeByteArrayToPath(Environment.getExternalStorageDirectory()+"/anysign/anysign.txt", str.getBytes());
//				Log.e("XSS", "anysign.txt is write");
				
				byte[] content = str.getBytes();
				try {
					if (path_anySign != null) {
						File file = new File(path_anySign);
						if (file.exists())
							file.delete();
						file.createNewFile();
						FileOutputStream fos = new FileOutputStream(file);
						if (content != null)
							fos.write(content);
						fos.flush();
						fos.close();
					}
				} catch (Exception e) {
					e.printStackTrace();
				}
				
				if (str != null && !"".equals(str)) {
					Toast.makeText(TestSPSAPIActivity.this, "打包成功" , Toast.LENGTH_SHORT).show();
				} else {
					Toast.makeText(TestSPSAPIActivity.this, "打包失败" , Toast.LENGTH_SHORT).show();
				}
			}else {
				Toast.makeText(app, "请先初始化API", Toast.LENGTH_SHORT).show();
			}
			
		} 
		
		else if (v.equals(upload)) {
			if (api != null) {
			
				
				new Thread() {
					public void run() {
						
						String url =	null;
						
						if(AnySignBuild.Default_Cert_EncAlg.equals("RSA")){
//						RSA
							url = "http://60.247.77.125:11208/AnySign_HttpServer/servlet/ReveivePADServer";
						}else if(AnySignBuild.Default_Cert_EncAlg.equals("SM2")){
//						SM2
							url = "http://60.247.77.125:11208/AnySign_HttpServer/servlet/ReveivePADServer";
						}
						
						String result = (String)api.genSignRequest();
						
//						sendData(result, url);
						
					}
				}.start();
				
			}
			
		} 
		else if (v.equals(resetAPI)) {
			
			if (api != null) {
				/*
				 * resetAPI() 重置api
				 */
				api.resetAPI();
				
				Toast.makeText(app, "RESET 成功，请重新配置签名等信息", Toast.LENGTH_SHORT).show();
			}else {
				Toast.makeText(app, "请先初始化API", Toast.LENGTH_SHORT).show();
			}
		}
		else if (v.equals(saveCacheWithSession)) {

			final EditText edt = new EditText(app);
			AlertDialog ad = new AlertDialog.Builder(app).setView(edt).setTitle("设置API缓存到的Session").setPositiveButton("确定", new DialogInterface.OnClickListener()
			{
				
				@Override
				public void onClick(DialogInterface dialog, int which)
				{
					int result = api.saveCacheDataWithSessionId(mSession = edt.getText().toString(), "111111");
					if (result == SignatureAPI.SUCCESS) {
						setTitle("SessionID:" + mSession);
					}else {
						Log.e("tagtag", result + "");
					}
					
				}
			}).create();
			ad.show();
		
		}
		else if (v.equals(readCacheWithSessionId)) {
			if(api.readCacheDataWithSessionId("888", "111111") == SignatureAPI.SUCCESS )
			{
				Log.e("tagtag", "缓存数据成功");
				Toast.makeText(app, "缓存数据成功", Toast.LENGTH_LONG).show();
			}else {
				Log.e("tagtag", api.readCacheDataWithSessionId(mSession, "111111") + "");
			}
		}
		else if (v.equals(deleteCacheWithSessionId)) {
			if (api.deleteCacheDataWithSessionId(mSession) == SignatureAPI.SUCCESS) {
				Log.e("tagtag", "删除缓存数据成功");
				Toast.makeText(app, "删除缓存数据成功", Toast.LENGTH_LONG).show();
			}
		}
		else if (v.equals(hasCacheWithSessionId)) {
			if (api.hasBufferedRecord(mSession)) {
				Log.e("tagtag", "查询缓存数据成功");
				Toast.makeText(app, "查询缓存数据成功", Toast.LENGTH_LONG).show();
			} else {
				Log.e("tagtag", "查询缓存数据失败");
				Toast.makeText(app, "查询缓存数据失败", Toast.LENGTH_LONG).show();
			}
		}
	}
	
	

	private void initApi(){
		try {
			// 设置签名算法，默认为RSA，可以设置成SM2
			 AnySignBuild.Default_Cert_EncAlg = "RSA";
			
			
			/*
			 *  初始化API
			 */
			api = new SignatureAPI(this);
			 
			/*
			 *  设置渠道号
			 */
//			所有api接口中设置成功返回 SignatureAPI.SUCCESS（0），其他错误
			apiResult = api.setChannel("123456");//业务渠道号，渠道号应该为小于20 位的数字，不能包含字母。
			Log.e("XSS", "apiResult -- setChannel：" + apiResult);
			if(apiResult == SignatureAPI.SUCCESS){
				Log.e("XSS", "apiResult -- setChannel：成功");
			}else{
				Log.e("XSS", "apiResult -- setChannel：失败");
			}
			/*
			 * 设置模版数据
			 */
			InputStream is = this.getResources().openRawResource(R.raw.testxml);
			bTemplate = new byte[is.available()];
			is.read(bTemplate);
//			 配置此次签名对应的模板数据
//			 参数1：表示模板类型，不可为空：如果为PDF和HTML格式，调用下面构造函数
//						ContextID.FORMDATA_PDF：PDF格式，ContextID.FORMDATA_HTML：HTML格式
//			 参数2：表示模板数据byte数组类型，不可为空
//			 参数3：业务流水号/工单号，不可为空
//			apiResult = api.setOrigialContent(new OriginalContent(OriginalContent.CONTENT_TYPE_HTML, bTemplate, "111"));
//			Log.e("XSS", "apiResult -- setOrigialContent：" + apiResult);
//			 配置此次签名对应的模板数据
//			 参数1：表示模板类型，不可为空：如果为XML格式，调用下面构造函数
//						ContextID.FORMDATA_XML: XML格式
//			 参数2：表示模板数据byte数组类型，不可为空
//			 参数3：业务流水号/工单号，不可为空
//			 参数4：模板序列号 参数1为ContextID.FORMDATA_XML时有效，不可为空；其他情况随便添加即可
			api.setOrigialContent(new OriginalContent(OriginalContent.CONTENT_TYPE_PDF, "123".getBytes(), "111","1990AC7450E51A74"));
			
			
			OCRCapture ocrCapture = new OCRCapture();
			ocrCapture.text = "a";
			ocrCapture.IPAdress = "http://60.247.77.116:11203/HWR/RecvServlet";
			ocrCapture.appID = "123";
			ocrCapture.count = 5;
			ocrCapture.resolution = 0;
			ocrCapture.serviceID = "999999";
			api.startOCR(ocrCapture);
			
			
			/*
			 * 注册手写签名对象，可注册多个
			 */
//			 实例化签名规则，三种方式，任选其一
//			SignRule signRule = SignRule.getInstance(SignRuleType.TYPE_KEY_WORD);
//			 方式一：使用关键字方式定位签名图片位置(根据偏移方向+偏移量，定位)
//			 参数1：keyWord - 关键字
//			 参数2：SigAlignMethod - 签名图片相对于关键字分布方法
//			 			at_right_bottom_corner_of_keyword 签字图片左上角和关键字右下角重合，可能额外附加偏移量
//		 				below_keyword 签字图片位于关键字正下方，中心线对齐
//			 			overlap 签字图片和关键字矩形重心重合
//			 			to_right_of_keyword 签字图片位于关键字正右方，中心线对齐
//			 参数3：offset - 按照alignMethod定位后，额外赋予的偏移量，单位dip
//			 参数4：从Pdf的第pageNo页开始搜索此关键字，直到找到或者pdf结束为止，从1开始，默认为1
//			 参数5：从Pdf的第pageNo页开始搜索第几个关键字，直到找到或者pdf结束为止，从第1页开始
//			signRule.setKWRule(new KWRule("甲", SigAlignMethod.to_right_of_keyword, 10, 1, 1));
//			 方式一：使用关键字方式定位签名图片位置(根据X轴偏移量+Y轴偏移量，定位)
//			 参数1：keyWord - 关键字
//			 参数2：XOffset -  签名图片相对于关键字X轴偏移量
//			 参数3：YOffset - 签名图片相对于关键字Y轴偏移量，单位dip
//			 参数4：从Pdf的第pageNo页开始搜索此关键字，直到找到或者pdf结束为止，从1开始，默认为1
//			 参数5：从Pdf的第pageNo页开始搜索第几个关键字，直到找到或者pdf结束为止，从第1页开始
//			signRule.setKWRule(new KWRule("投保人签名", SigAlignMethod.to_right_of_keyword, 10, 1, 1));
			
//			 方式二：使用坐标定位签名图片位置
//			 参数1：left - 签名图片最左边坐标值，相对于PDF当页最左下角(0,0)点
//			 参数2：top - 签名图片顶边坐标值，相对于PDF当页最左下角(0,0)点
//			 参数3：right - 签名图片最右边坐标值，相对于PDF当页最左下角(0,0)点
//			 参数4：bottom - 签名图片底边坐标值，相对于PDF当页最左下角(0,0)点
//			 参数5：pageNo - 签名在PDF中的页码
//			 参数5：unit - 坐标单位
			SignRule signRule = SignRule.getInstance(SignRuleType.TYPE_XYZ);
			signRule.setXYZRule(new XYZRule(84, 523, 200, 411, 1,"dp"));
			
//			 方式三：使用在服务器端配置好的信息定位签名图片位置
//			 参数1：123为服务器配置好的签名规则
//			signRule = SignRule.getInstance(SignRuleType.TYPE_USE_SERVER_SIDE_CONFIG);
//			rule.setServerConfigRule("123");
			
//			 实例化签名人信息
//			参数1：姓名
//			参数2：唯一id,身份证等
//			参数3：证件类型
//						SignerCardType.TYPE_IDENTITY_CARD 身份证
//						SignerCardType.TYPE_OFFICER_CARD	军官证
//						SignerCardType.TYPE_PASSPORT_CARD	护照
//						SignerCardType.TYPE_RESIDENT_CARD	户口页
			Signer signer = new Signer("王二", "222", SignerCardType.TYPE_IDENTITY_CARD);
//			实例化手写签名对象
//			参数1：手写签名对象索引值
			SignatureObj obj = new SignatureObj(0,signRule,signer);
//			设置签名人信息
			obj.Signer = signer;
//			设置签名规则
			obj.SignRule = signRule;
//			设置签名图片高度，单位dip			 
			obj.single_height = 100;
//			设置签名图片宽度，单位dip
			 obj.single_width = 100;
//			设置签名对话框的高度，单位dip			 
			obj.single_dialog_height = 500;
//			设置签名对话框的宽度，单位dip
			 obj.single_dialog_width = 600;
			 obj.enableSignatureRecording = true;
//			 obj.openCamera = true;
//			 obj.openFaceDetection = true;
////			是否开启 时间戳，默认为false
//			obj.IsTSS = true;
////			 签名是否必须,设置为true时必须进行签名，默认true
			obj.nessesary = false;
////			 设置签名笔迹颜色，默认为黑色
//			obj.penColor = Color.RED;
////			 对此签名增加签名时间标记
//			obj.TimeTag = new TimeTag(Position.above_sign_img,	"yyyy-MM-dd HH:mm:ss");
////			 需要显示在签名框顶栏的标题
//			obj.title = "请李白签名";
////			单字签名框中需要突出显示部分的起始位置和结束位置
//			obj.titleSpanFromOffset = 1;
////			单字签名框中需要突出显示部分的起始位置和结束位置
//			obj.titleSpanToOffset = 2;
//			 obj.sign_dlg_type = SignInputType.Normal;
//			 obj.isdistinguish = true;
			 


//			 注册单签签名对象
			 apiResult = api.addSignatureObj(obj);
			Log.e("XSS", "apiResult -- addSignatureObj：" + apiResult);
			
			
			SignRule signRule_1 = SignRule.getInstance(SignRuleType.TYPE_KEY_WORD);
			signRule_1.setKWRule(new KWRule("投保人签名", KWRule.SigAlignMethod.to_right_of_keyword, 1, 1, 1));
			
			SignatureObj obj_1 = new SignatureObj(1,signRule_1,signer);
//			设置签名人信息
			obj_1.Signer = signer;
//			设置签名规则
			obj_1.SignRule = signRule_1;
//			设置签名图片高度，单位dip			 
			obj_1.single_height = 100;
//			设置签名图片宽度，单位dip
			obj_1.single_width = 100;
//			设置签名对话框的高度，单位dip			 
			obj_1.single_dialog_height = 500;
//			设置签名对话框的宽度，单位dip
			obj_1.single_dialog_width = 600;
			obj_1.enableSignatureRecording = true;
////			是否开启 时间戳，默认为false
//			obj.IsTSS = true;
////			 签名是否必须,设置为true时必须进行签名，默认true
			obj_1.nessesary = false;
			
////			 设置签名笔迹颜色，默认为黑色
//			obj.penColor = Color.RED;
////			 对此签名增加签名时间标记
//			obj.TimeTag = new TimeTag(Position.above_sign_img,	"yyyy-MM-dd HH:mm:ss");
////			 需要显示在签名框顶栏的标题
//			obj.title = "请李白签名";
////			单字签名框中需要突出显示部分的起始位置和结束位置
//			obj.titleSpanFromOffset = 1;
////			单字签名框中需要突出显示部分的起始位置和结束位置
//			obj.titleSpanToOffset = 2;
			 
			 
//			 注册单签签名对象
			 apiResult = api.addSignatureObj(obj_1);
			
			
			/*
			 * 注册批注对象，可注册多个
			 */
//			 实例化签名规则，签名规则跟手写签名一样
			signRule = SignRule.getInstance(SignRuleType.TYPE_KEY_WORD);
//			 方式一：使用关键字方式定位签名图片位置(根据偏移方向+偏移量，定位)
//			 参数1：keyWord - 关键字
//			 参数2：SigAlignMethod - 签名图片相对于关键字分布方法
//			 			at_right_bottom_corner_of_keyword 签字图片左上角和关键字右下角重合，可能额外附加偏移量
//		 				below_keyword 签字图片位于关键字正下方，中心线对齐
//			 			overlap 签字图片和关键字矩形重心重合
//			 			to_right_of_keyword 签字图片位于关键字正右方，中心线对齐
//			 参数3：offset - 按照alignMethod定位后，额外赋予的偏移量，单位dip
//			 参数4：从Pdf的第pageNo页开始搜索此关键字，直到找到或者pdf结束为止，从1开始，默认为1
//			 参数5：从Pdf的第pageNo页开始搜索第几个关键字，直到找到或者pdf结束为止，从第1页开始
//			signRule.setKWRule(new KWRule("申请人", SigAlignMethod.to_right_of_keyword, 10, 1, 1));
			
			SignRule signRule1 = SignRule.getInstance(SignRuleType.TYPE_KEY_WORD);
//			signRule1.setKWRule(new KWRule("的", SigAlignMethod.to_right_of_keyword, 80, 2, 1));
			signRule1.setKWRule(new KWRule("本人已阅读", 200, -90, 0, 0));
			
//			 实例化签名人信息
//			参数1：姓名
//			参数2：唯一id,身份证等
//			参数3：证件类型
//						SignerCardType.TYPE_IDENTITY_CARD 身份证
//						SignerCardType.TYPE_OFFICER_CARD	军官证
//						SignerCardType.TYPE_PASSPORT_CARD	护照
//						SignerCardType.TYPE_RESIDENT_CARD	户口页
			signer = new Signer("11", "222", SignerCardType.TYPE_IDENTITY_CARD);
//			实例化批注对象
//			参数1：批注对象索引值
			CommentObj massobj = new CommentObj(0,signRule1,signer);
//			设置签名人信息
			massobj.Signer = signer;
//			设置签名规则
//			massobj.SignRule = signRule1;
//			if (isPad(TestSPSAPIActivity.this)) {
				massobj.mass_dlg_type = CommentInputType.Scrollable;
//			} else {
//				massobj.mass_dlg_type = CommentInputType.Normal;
//			}
			
//			批注内容
//			massobj.commitment = "本人已阅读保险条款、产品说明书和投保提示书，了解本产品的特点和保单利益的不确定";           
			massobj.commitment = "本人已阅读";           
//			生成的签名图片中单行显示的字数			
			 massobj.mass_words_in_single_line = 15;
//			生成的签名图片中单个字的高
			 massobj.mass_word_height = 100;
//			生成的签名图片中单个字的宽
			 massobj.mass_word_width = 100;
//			 签名是否必须,设置为true时必须进行签名，默认true
			 massobj.nessesary = false;
//			设置笔迹颜色，默认为黑色
//			massobj.penColor = Color.RED;
			 
			 massobj.isdistinguish = true;
			 
//			 注册批注对象
			 apiResult = api.addCommentObj(massobj);
			Log.e("XSS", "apiResult -- addCommentObj：" + apiResult);
			
//			/*
//			 * 注册单位章
//			 */
////			 实例化签名人信息
////			参数1：单位名称
////			参数2：唯一id,身份证等
			signer = new Signer("11", "222");
////			实例化签章对象
////			参数1：服务端配置好的公章规则
////			参数2：公章信息，可以为空，因为公章属性默认使用服务端配置
			CachetObj cachetObj = new CachetObj("1703", signer);
////			是否开启时间戳
			cachetObj.IsTSS = false;
////			注册单位章
//			apiResult = api.addChachetObj(cachetObj);
//			Log.e("XSS", "apiResult -- addChachetObj：" + apiResult);
			
		} catch (Exception e1) {
			e1.printStackTrace();
		}
		/*
		 * 注册签名结果回调函数
		 */
		api.setOnSignatureResultListener(new OnSignatureResultListener() {


			@Override
			public void onSignResult(SignResult signResult)
			{
//				在这里取签名图片
//				参数1：签名索引值
//				参数2：签名图片
				Log.e("tagtag", "signIndex: " + signResult.signIndex);
				Toast.makeText(app, "signIndex: " + signResult.signIndex + "-->resultCode: " + signResult.resultCode + "-->signType: " + signResult.signType, Toast.LENGTH_LONG).show();
				Log.e("tagtag","pointStrack: " + signResult.pointStack);
				showImgPreviewDlg(signResult.signature,signResult.signIndex);
			}

			@Override
			public void onDismiss(int index, SignatureType signType)
			{
				// TODO Auto-generated method stub
				Toast.makeText(app, "已清除" , Toast.LENGTH_LONG).show();
			}

			@Override
			public void onCancel(int index, SignatureType signType)
			{
				// TODO Auto-generated method stub
				Toast.makeText(app, "已关闭" , Toast.LENGTH_LONG).show();
			}
		});
		
		

	}

	private boolean isPad(Context context) {
		return (context.getResources().getConfiguration().screenLayout
	            & Configuration.SCREENLAYOUT_SIZE_MASK) 
	            >= Configuration.SCREENLAYOUT_SIZE_LARGE;
	}




	private void showImgPreviewDlg(Bitmap img,int index) {
		ImageView iv = new ImageView(app);
		iv.setBackgroundColor(Color.WHITE);
		iv.setImageBitmap(img);
		new AlertDialog.Builder(app).setView(iv).show();
		
		saveBitmap(img, "pic"+index+".png");
	}

	@Override
	public void finish() {
		if (null != api)
			
			/*
			 * finalizeAPI() 释放api
			 * */
			api.finalizeAPI();
		super.finish();
	}

	
//	private String sendData(String data, String url) {
//		String result = "";
//		Log.e("XSS", url);
//		
//		OkHttpUtils
//		    .post()
//		    .url(url)
//		    .addParams("padjson", data)
//		    .build()
//		    .execute(new StringCallback() {
//				
//				@Override
//				public void onResponse(String response, int id) {
//					// TODO Auto-generated method stub
//					Log.e("tagtag", "response: " + response);
//				}
//				
//				@Override
//				public void onError(Call call, Exception e, int id) {
//					// TODO Auto-generated method stub
//					e.printStackTrace();
//				}
//			});
//		
//		return result;
//	}
	
	public void saveBitmap(Bitmap bm,String picName) {
		try {
			if (root_path != null) {
				String subForder = root_path;
				File foder = new File(subForder);
				if (!foder.exists()) {
				foder.mkdirs();
				}
				File file = new File(root_path,picName);
				if (file.exists())
					file.delete();
				file.createNewFile();
				FileOutputStream out = new FileOutputStream(file);
				bm.compress(Bitmap.CompressFormat.PNG, 90, out);
				out.flush();
				out.close();
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public static byte[] readFile2BytesByStream(final File file) {
        FileInputStream fis = null;
        ByteArrayOutputStream os = null;
        try {
            fis = new FileInputStream(file);
            os = new ByteArrayOutputStream();
            byte[] b = new byte[8192];
            int len;
            while ((len = fis.read(b, 0, 8192)) != -1) {
                os.write(b, 0, len);
            }
            return os.toByteArray();
        } catch (IOException e) {
            e.printStackTrace();
            return null;
        } 
    }
	
}
